home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / rdflib / syntax / serializers / RecursiveSerializer.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  5.8 KB  |  139 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. from rdflib.BNode import BNode
  5. from rdflib.Literal import Literal
  6. from rdflib.URIRef import URIRef
  7. from rdflib.syntax.serializers.AbstractSerializer import AbstractSerializer
  8. from rdflib import RDF, RDFS
  9.  
  10. class RecursiveSerializer(AbstractSerializer):
  11.     topClasses = [
  12.         RDFS.Class]
  13.     predicateOrder = [
  14.         RDF.type,
  15.         RDFS.label]
  16.     maxDepth = 10
  17.     indentString = u'  '
  18.     
  19.     def __init__(self, store):
  20.         super(RecursiveSerializer, self).__init__(store)
  21.         self.stream = None
  22.         self.reset()
  23.  
  24.     
  25.     def addNamespace(self, prefix, uri):
  26.         self.namespaces[prefix] = uri
  27.  
  28.     
  29.     def checkSubject(self, subject):
  30.         '''Check to see if the subject should be serialized yet'''
  31.         if not self.isDone(subject) and subject not in self._subjects:
  32.             if (subject in self._topLevels or self.depth > 1 or isinstance(subject, URIRef)) and self.depth >= self.maxDepth:
  33.                 return False
  34.             return True
  35.  
  36.     
  37.     def isDone(self, subject):
  38.         '''Return true if subject is serialized'''
  39.         return subject in self._serialized
  40.  
  41.     
  42.     def orderSubjects(self):
  43.         seen = { }
  44.         subjects = []
  45.         for classURI in self.topClasses:
  46.             members = list(self.store.subjects(RDF.type, classURI))
  47.             members.sort()
  48.             for member in members:
  49.                 subjects.append(member)
  50.                 self._topLevels[member] = True
  51.                 seen[member] = True
  52.             
  53.         
  54.         recursable = _[1]
  55.         recursable.sort()
  56.         []([ subject for isbnode, refs, subject in recursable ])
  57.         return subjects
  58.  
  59.     
  60.     def preprocess(self):
  61.         for triple in self.store.triples((None, None, None)):
  62.             self.preprocessTriple(triple)
  63.         
  64.  
  65.     
  66.     def preprocessTriple(self, .1):
  67.         (s, p, o) = .1
  68.         references = self.refCount(o) + 1
  69.         self._references[o] = references
  70.         self._subjects[s] = True
  71.  
  72.     
  73.     def refCount(self, node):
  74.         '''Return the number of times this node has been referenced in the object position'''
  75.         return self._references.get(node, 0)
  76.  
  77.     
  78.     def reset(self):
  79.         self.depth = 0
  80.         self.lists = { }
  81.         self.namespaces = { }
  82.         self._references = { }
  83.         self._serialized = { }
  84.         self._subjects = { }
  85.         self._topLevels = { }
  86.  
  87.     
  88.     def buildPredicateHash(self, subject):
  89.         '''Build a hash key by predicate to a list of objects for the given subject'''
  90.         properties = { }
  91.         for s, p, o in self.store.triples((subject, None, None)):
  92.             oList = properties.get(p, [])
  93.             oList.append(o)
  94.             properties[p] = oList
  95.         
  96.         return properties
  97.  
  98.     
  99.     def sortProperties(self, properties):
  100.         '''Take a hash from predicate uris to lists of values.
  101.            Sort the lists of values.  Return a sorted list of properties.'''
  102.         for prop, objects in properties.items():
  103.             objects.sort()
  104.         
  105.         propList = []
  106.         seen = { }
  107.         for prop in self.predicateOrder:
  108.             if prop in properties and prop not in seen:
  109.                 propList.append(prop)
  110.                 seen[prop] = True
  111.                 continue
  112.         
  113.         props = properties.keys()
  114.         props.sort()
  115.         for prop in props:
  116.             if prop not in seen:
  117.                 propList.append(prop)
  118.                 seen[prop] = True
  119.                 continue
  120.         
  121.         return propList
  122.  
  123.     
  124.     def subjectDone(self, subject):
  125.         '''Mark a subject as done.'''
  126.         self._serialized[subject] = True
  127.  
  128.     
  129.     def indent(self, modifier = 0):
  130.         '''Returns indent string multiplied by the depth'''
  131.         return (self.depth + modifier) * self.indentString
  132.  
  133.     
  134.     def write(self, text):
  135.         '''Write text in given encoding.'''
  136.         self.stream.write(text.encode(self.encoding, 'replace'))
  137.  
  138.  
  139.